#ifndef __example_H__
#define __example_H__
#include <string>
#include <list>
#include <vector>
#include <map>
#include <cstring>
#include <stdint.h>

//#include "other_idl.h"

struct slot {
	bool	open;
	uint32_t	seq;
	char	classtype;
	uint32_t	level;
	std::string	reg_date;
	slot()	{
		open = false;
		seq = 0;
		classtype = '\0';
		level = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(bool);
		nSize += sizeof(uint32_t);
		nSize += sizeof(char);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += reg_date.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(bool*)(*_buf_)) = open; (*_buf_) += sizeof(bool);
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(char*)(*_buf_)) = classtype; (*_buf_) += sizeof(char);
		(*(uint32_t*)(*_buf_)) = level; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)reg_date.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, reg_date.c_str(), reg_date.length());
		(*_buf_) += reg_date.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(bool) > nSize) { return false; }	std::memcpy(&open, *_buf_, sizeof(bool));	(*_buf_) += sizeof(bool); nSize -= sizeof(bool);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(char) > nSize) { return false; }	std::memcpy(&classtype, *_buf_, sizeof(char));	(*_buf_) += sizeof(char); nSize -= sizeof(char);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&level, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t reg_date_length = 0; std::memcpy(&reg_date_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		reg_date.assign((char*)*_buf_, reg_date_length); (*_buf_) += reg_date_length; nSize -= reg_date_length;
		return true;
	}
}; //slot
struct slot_Serializer {
	static bool Store(char** _buf_, const slot& obj) { return obj.Store(_buf_); }
	static bool Load(slot& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const slot& obj) { return obj.Size(); }
};
struct UserInfo {
	uint32_t	seq;
	slot	array_Slot[8];
	uint32_t	zen;
	uint32_t	main_slot_seq;
	std::string	nickname;
	std::string	profile_url;
	uint32_t	score;
	uint32_t	heart_blocked;
	uint32_t	invite_blocked;
	uint32_t	profile_opened;
	UserInfo()	{
		seq = 0;
		zen = 0;
		main_slot_seq = 0;
		score = 0;
		heart_blocked = 0;
		invite_blocked = 0;
		profile_opened = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		for(int32_t i=0; i<8; i++) {
			nSize += slot_Serializer::Size(array_Slot[i]);
		}
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += nickname.length();
		nSize += sizeof(int32_t); nSize += profile_url.length();
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		for(int32_t i=0; i<8; i++) {
			if(false == slot_Serializer::Store(_buf_, array_Slot[i])) { return false; }
		}
		(*(uint32_t*)(*_buf_)) = zen; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = main_slot_seq; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)nickname.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, nickname.c_str(), nickname.length());
		(*_buf_) += nickname.length();
		(*(int32_t*)(*_buf_)) = (int32_t)profile_url.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, profile_url.c_str(), profile_url.length());
		(*_buf_) += profile_url.length();
		(*(uint32_t*)(*_buf_)) = score; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_blocked; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = invite_blocked; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = profile_opened; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		for(int32_t i=0; i<8; i++) {
			slot array_Slot_val;
			if(false == slot_Serializer::Load(array_Slot_val, _buf_, nSize)) { return false; }
			array_Slot[i] = array_Slot_val;
		}
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&zen, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&main_slot_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t nickname_length = 0; std::memcpy(&nickname_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		nickname.assign((char*)*_buf_, nickname_length); (*_buf_) += nickname_length; nSize -= nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t profile_url_length = 0; std::memcpy(&profile_url_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		profile_url.assign((char*)*_buf_, profile_url_length); (*_buf_) += profile_url_length; nSize -= profile_url_length;
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&score, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_blocked, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&invite_blocked, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&profile_opened, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //UserInfo
struct UserInfo_Serializer {
	static bool Store(char** _buf_, const UserInfo& obj) { return obj.Store(_buf_); }
	static bool Load(UserInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UserInfo& obj) { return obj.Size(); }
};
struct QuickSlot {
	uint32_t	type;
	uint32_t	index;
	QuickSlot()	{
		type = 0;
		index = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = type; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = index; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&type, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&index, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //QuickSlot
struct QuickSlot_Serializer {
	static bool Store(char** _buf_, const QuickSlot& obj) { return obj.Store(_buf_); }
	static bool Load(QuickSlot& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const QuickSlot& obj) { return obj.Size(); }
};
struct CharacterInfo {
	uint32_t	seq;
	char	classtype;
	uint32_t	remain_stat_point;
	uint32_t	remain_skill_point;
	uint32_t	ap_current;
	uint32_t	ep_current;
	uint32_t	ep_max;
	uint32_t	head;
	uint32_t	body;
	uint32_t	pri_weapon;
	uint32_t	sec_weapon;
	uint32_t	effect;
	uint32_t	vehicle;
	uint32_t	exp;
	uint32_t	level;
	uint32_t	str;
	uint32_t	dex;
	uint32_t	con;
	uint32_t	spi;
	uint32_t	array_Skill[20];
	QuickSlot	array_QuickSlot[8];
	uint32_t	gold;
	std::string	reg_date;
	CharacterInfo()	{
		seq = 0;
		classtype = '\0';
		remain_stat_point = 0;
		remain_skill_point = 0;
		ap_current = 0;
		ep_current = 0;
		ep_max = 0;
		head = 0;
		body = 0;
		pri_weapon = 0;
		sec_weapon = 0;
		effect = 0;
		vehicle = 0;
		exp = 0;
		level = 0;
		str = 0;
		dex = 0;
		con = 0;
		spi = 0;
		gold = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(char);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t) * 20;
		for(int32_t i=0; i<8; i++) {
			nSize += QuickSlot_Serializer::Size(array_QuickSlot[i]);
		}
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += reg_date.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(char*)(*_buf_)) = classtype; (*_buf_) += sizeof(char);
		(*(uint32_t*)(*_buf_)) = remain_stat_point; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = remain_skill_point; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = ap_current; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = ep_current; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = ep_max; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = head; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = body; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = pri_weapon; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = sec_weapon; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = effect; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = vehicle; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = exp; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = level; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = str; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = dex; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = con; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = spi; (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, array_Skill, sizeof(uint32_t) * 20); (*_buf_) += sizeof(uint32_t) * 20;
		for(int32_t i=0; i<8; i++) {
			if(false == QuickSlot_Serializer::Store(_buf_, array_QuickSlot[i])) { return false; }
		}
		(*(uint32_t*)(*_buf_)) = gold; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)reg_date.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, reg_date.c_str(), reg_date.length());
		(*_buf_) += reg_date.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(char) > nSize) { return false; }	std::memcpy(&classtype, *_buf_, sizeof(char));	(*_buf_) += sizeof(char); nSize -= sizeof(char);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&remain_stat_point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&remain_skill_point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&ap_current, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&ep_current, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&ep_max, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&head, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&body, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&pri_weapon, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&sec_weapon, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&effect, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&vehicle, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&exp, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&level, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&str, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&dex, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&con, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&spi, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		std::memcpy(array_Skill, *_buf_, sizeof(uint32_t) * 20); (*_buf_) += sizeof(uint32_t) * 20; nSize -= sizeof(uint32_t) * 20;
		for(int32_t i=0; i<8; i++) {
			QuickSlot array_QuickSlot_val;
			if(false == QuickSlot_Serializer::Load(array_QuickSlot_val, _buf_, nSize)) { return false; }
			array_QuickSlot[i] = array_QuickSlot_val;
		}
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gold, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t reg_date_length = 0; std::memcpy(&reg_date_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		reg_date.assign((char*)*_buf_, reg_date_length); (*_buf_) += reg_date_length; nSize -= reg_date_length;
		return true;
	}
}; //CharacterInfo
struct CharacterInfo_Serializer {
	static bool Store(char** _buf_, const CharacterInfo& obj) { return obj.Store(_buf_); }
	static bool Load(CharacterInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const CharacterInfo& obj) { return obj.Size(); }
};
struct UserInfoSyn {
	enum { MSG_ID = 501 }; 
	uint32_t	seq;
	UserInfoSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //UserInfoSyn
struct UserInfoSyn_Serializer {
	static bool Store(char** _buf_, const UserInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UserInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UserInfoSyn& obj) { return obj.Size(); }
};
struct UserInfoAck {
	enum { MSG_ID = 502 }; 
	uint32_t	seq;
	uint32_t	result;
	std::string	strError;
	UserInfo	stUserInfo;
	UserInfoAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += strError.length();
		nSize += UserInfo_Serializer::Size(stUserInfo);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = result; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)strError.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, strError.c_str(), strError.length());
		(*_buf_) += strError.length();
		if(false == UserInfo_Serializer::Store(_buf_, stUserInfo)) { return false; }
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t strError_length = 0; std::memcpy(&strError_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		strError.assign((char*)*_buf_, strError_length); (*_buf_) += strError_length; nSize -= strError_length;
		if(false == UserInfo_Serializer::Load(stUserInfo, _buf_, nSize)) { return false; }
		return true;
	}
}; //UserInfoAck
struct UserInfoAck_Serializer {
	static bool Store(char** _buf_, const UserInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(UserInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UserInfoAck& obj) { return obj.Size(); }
};
struct CharacterInfoSyn {
	enum { MSG_ID = 503 }; 
	uint32_t	seq;
	uint32_t	char_seq;
	CharacterInfoSyn()	{
		seq = 0;
		char_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = char_seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&char_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //CharacterInfoSyn
struct CharacterInfoSyn_Serializer {
	static bool Store(char** _buf_, const CharacterInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(CharacterInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const CharacterInfoSyn& obj) { return obj.Size(); }
};
struct CharacterInfoAck {
	enum { MSG_ID = 504 }; 
	uint32_t	seq;
	uint32_t	result;
	std::string	strError;
	CharacterInfo	stCharacterInfo;
	CharacterInfoAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += strError.length();
		nSize += CharacterInfo_Serializer::Size(stCharacterInfo);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = result; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)strError.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, strError.c_str(), strError.length());
		(*_buf_) += strError.length();
		if(false == CharacterInfo_Serializer::Store(_buf_, stCharacterInfo)) { return false; }
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t strError_length = 0; std::memcpy(&strError_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		strError.assign((char*)*_buf_, strError_length); (*_buf_) += strError_length; nSize -= strError_length;
		if(false == CharacterInfo_Serializer::Load(stCharacterInfo, _buf_, nSize)) { return false; }
		return true;
	}
}; //CharacterInfoAck
struct CharacterInfoAck_Serializer {
	static bool Store(char** _buf_, const CharacterInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(CharacterInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const CharacterInfoAck& obj) { return obj.Size(); }
};
struct FlushCharacterInfoSyn {
	enum { MSG_ID = 505 }; 
	uint32_t	seq;
	uint32_t	char_seq;
	bool	flushDB;
	CharacterInfo	stCharacterInfo;
	FlushCharacterInfoSyn()	{
		seq = 0;
		char_seq = 0;
		flushDB = false;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(bool);
		nSize += CharacterInfo_Serializer::Size(stCharacterInfo);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = char_seq; (*_buf_) += sizeof(uint32_t);
		(*(bool*)(*_buf_)) = flushDB; (*_buf_) += sizeof(bool);
		if(false == CharacterInfo_Serializer::Store(_buf_, stCharacterInfo)) { return false; }
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&char_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(bool) > nSize) { return false; }	std::memcpy(&flushDB, *_buf_, sizeof(bool));	(*_buf_) += sizeof(bool); nSize -= sizeof(bool);
		if(false == CharacterInfo_Serializer::Load(stCharacterInfo, _buf_, nSize)) { return false; }
		return true;
	}
}; //FlushCharacterInfoSyn
struct FlushCharacterInfoSyn_Serializer {
	static bool Store(char** _buf_, const FlushCharacterInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(FlushCharacterInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FlushCharacterInfoSyn& obj) { return obj.Size(); }
};
struct FlushCharacterInfoAck {
	enum { MSG_ID = 506 }; 
	uint32_t	seq;
	uint32_t	result;
	std::string	strError;
	FlushCharacterInfoAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += strError.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = result; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)strError.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, strError.c_str(), strError.length());
		(*_buf_) += strError.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t strError_length = 0; std::memcpy(&strError_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		strError.assign((char*)*_buf_, strError_length); (*_buf_) += strError_length; nSize -= strError_length;
		return true;
	}
}; //FlushCharacterInfoAck
struct FlushCharacterInfoAck_Serializer {
	static bool Store(char** _buf_, const FlushCharacterInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(FlushCharacterInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FlushCharacterInfoAck& obj) { return obj.Size(); }
};
struct FlushUserInfoSyn {
	enum { MSG_ID = 507 }; 
	uint32_t	seq;
	bool	flushDB;
	UserInfo	stUserInfo;
	FlushUserInfoSyn()	{
		seq = 0;
		flushDB = false;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(bool);
		nSize += UserInfo_Serializer::Size(stUserInfo);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(bool*)(*_buf_)) = flushDB; (*_buf_) += sizeof(bool);
		if(false == UserInfo_Serializer::Store(_buf_, stUserInfo)) { return false; }
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(bool) > nSize) { return false; }	std::memcpy(&flushDB, *_buf_, sizeof(bool));	(*_buf_) += sizeof(bool); nSize -= sizeof(bool);
		if(false == UserInfo_Serializer::Load(stUserInfo, _buf_, nSize)) { return false; }
		return true;
	}
}; //FlushUserInfoSyn
struct FlushUserInfoSyn_Serializer {
	static bool Store(char** _buf_, const FlushUserInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(FlushUserInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FlushUserInfoSyn& obj) { return obj.Size(); }
};
struct FlushUserInfoAck {
	enum { MSG_ID = 508 }; 
	uint32_t	seq;
	uint32_t	result;
	std::string	strError;
	FlushUserInfoAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += strError.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = result; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)strError.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, strError.c_str(), strError.length());
		(*_buf_) += strError.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t strError_length = 0; std::memcpy(&strError_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		strError.assign((char*)*_buf_, strError_length); (*_buf_) += strError_length; nSize -= strError_length;
		return true;
	}
}; //FlushUserInfoAck
struct FlushUserInfoAck_Serializer {
	static bool Store(char** _buf_, const FlushUserInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(FlushUserInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FlushUserInfoAck& obj) { return obj.Size(); }
};
struct FlushUserSlotInfoSyn {
	enum { MSG_ID = 509 }; 
	uint32_t	seq;
	uint32_t	slotIndex;
	slot	stSlot;
	FlushUserSlotInfoSyn()	{
		seq = 0;
		slotIndex = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += slot_Serializer::Size(stSlot);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = slotIndex; (*_buf_) += sizeof(uint32_t);
		if(false == slot_Serializer::Store(_buf_, stSlot)) { return false; }
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&slotIndex, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(false == slot_Serializer::Load(stSlot, _buf_, nSize)) { return false; }
		return true;
	}
}; //FlushUserSlotInfoSyn
struct FlushUserSlotInfoSyn_Serializer {
	static bool Store(char** _buf_, const FlushUserSlotInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(FlushUserSlotInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FlushUserSlotInfoSyn& obj) { return obj.Size(); }
};
struct FlushUserSlotInfoAck {
	enum { MSG_ID = 510 }; 
	uint32_t	seq;
	uint32_t	result;
	std::string	strError;
	FlushUserSlotInfoAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += strError.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = result; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)strError.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, strError.c_str(), strError.length());
		(*_buf_) += strError.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t strError_length = 0; std::memcpy(&strError_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		strError.assign((char*)*_buf_, strError_length); (*_buf_) += strError_length; nSize -= strError_length;
		return true;
	}
}; //FlushUserSlotInfoAck
struct FlushUserSlotInfoAck_Serializer {
	static bool Store(char** _buf_, const FlushUserSlotInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(FlushUserSlotInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FlushUserSlotInfoAck& obj) { return obj.Size(); }
};
struct RemoveUser {
	enum { MSG_ID = 511 }; 
	uint32_t	seq;
	RemoveUser()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //RemoveUser
struct RemoveUser_Serializer {
	static bool Store(char** _buf_, const RemoveUser& obj) { return obj.Store(_buf_); }
	static bool Load(RemoveUser& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const RemoveUser& obj) { return obj.Size(); }
};
#endif // __example_H__
